{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# StellarGraph Ensemble for link prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we use `stellargraph`s `BaggingEnsemble` class of [GraphSAGE](http://snap.stanford.edu/graphsage/) models to predict citation links in the Cora dataset (see below). The `BaggingEnsemble` class brings ensemble learning to `stellargraph`'s graph neural network models, e.g., `GraphSAGE`, quantifying prediction variance and potentially improving prediction accuracy. \n",
    "\n",
    "The problem is treated as a supervised link prediction problem on a homogeneous citation network with nodes representing papers (with attributes such as binary keyword indicators and categorical subject) and links corresponding to paper-paper citations. \n",
    "\n",
    "To address this problem, we build a a base `GraphSAGE` model with the following architecture. First we build a two-layer GraphSAGE model that takes labeled `(paper1, paper2)` node pairs corresponding to possible citation links, and outputs a pair of node embeddings for the `paper1` and `paper2` nodes of the pair. These embeddings are then fed into a link classification layer, which first applies a binary operator to those node embeddings (e.g., concatenating them) to construct the embedding of the potential link. Thus obtained link embeddings are passed through the dense link classification layer to obtain link predictions - probability for these candidate links to actually exist in the network. The entire model is trained end-to-end by minimizing the loss function of choice (e.g., binary cross-entropy between predicted link probabilities and true link labels, with true/false citation links having labels 1/0) using stochastic gradient descent (SGD) updates of the model parameters, with minibatches of 'training' links fed into the model.\n",
    "\n",
    "Finally, using our base model, we create an ensemble with each model in the ensemble trained on a bootstrapped sample of the training data. \n",
    "\n",
    "**References**\n",
    "\n",
    "1. Inductive Representation Learning on Large Graphs. W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216 \n",
    "[cs.SI], 2017."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from tensorflow import keras\n",
    "import os\n",
    "\n",
    "import stellargraph as sg\n",
    "from stellargraph.data import EdgeSplitter\n",
    "from stellargraph.mapper import GraphSAGELinkGenerator\n",
    "from stellargraph.layer import GraphSAGE, link_classification\n",
    "from stellargraph import BaggingEnsemble\n",
    "\n",
    "from sklearn import preprocessing, feature_extraction, model_selection\n",
    "\n",
    "from stellargraph import globalvar\n",
    "from stellargraph import datasets\n",
    "from IPython.display import display, HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_history(history):\n",
    "    def remove_prefix(text, prefix):\n",
    "        return text[text.startswith(prefix) and len(prefix) :]\n",
    "\n",
    "    figsize = (7, 5)\n",
    "    c_train = \"b\"\n",
    "    c_test = \"g\"\n",
    "\n",
    "    metrics = sorted(\n",
    "        set([remove_prefix(m, \"val_\") for m in list(history[0].history.keys())])\n",
    "    )\n",
    "    for m in metrics:\n",
    "        # summarize history for metric m\n",
    "        plt.figure(figsize=figsize)\n",
    "        for h in history:\n",
    "            plt.plot(h.history[m], c=c_train)\n",
    "            plt.plot(h.history[\"val_\" + m], c=c_test)\n",
    "\n",
    "        plt.title(m)\n",
    "        plt.ylabel(m)\n",
    "        plt.xlabel(\"epoch\")\n",
    "        plt.legend([\"train\", \"validation\"], loc=\"best\")\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_cora(data_dir, largest_cc=False):\n",
    "    g_nx = nx.read_edgelist(path=os.path.expanduser(os.path.join(data_dir, \"cora.cites\")))\n",
    "\n",
    "    for edge in g_nx.edges(data=True):\n",
    "        edge[2][\"label\"] = \"cites\"\n",
    "\n",
    "    # load the node attribute data\n",
    "    cora_data_location = os.path.expanduser(os.path.join(data_dir, \"cora.content\"))\n",
    "    node_attr = pd.read_csv(cora_data_location, sep=\"\\t\", header=None)\n",
    "    values = {str(row.tolist()[0]): row.tolist()[-1] for _, row in node_attr.iterrows()}\n",
    "    nx.set_node_attributes(g_nx, values, \"subject\")\n",
    "\n",
    "    if largest_cc:\n",
    "        # Select the largest connected component. For clarity we ignore isolated\n",
    "        # nodes and subgraphs; having these in the data does not prevent the\n",
    "        # algorithm from running and producing valid results.\n",
    "        g_nx_ccs = (g_nx.subgraph(c).copy() for c in nx.connected_components(g_nx))\n",
    "        g_nx = max(g_nx_ccs, key=len)\n",
    "        print(\n",
    "            \"Largest subgraph statistics: {} nodes, {} edges\".format(\n",
    "                g_nx.number_of_nodes(), g_nx.number_of_edges()\n",
    "            )\n",
    "        )\n",
    "\n",
    "    feature_names = [\"w_{}\".format(ii) for ii in range(1433)]\n",
    "    column_names = feature_names + [\"subject\"]\n",
    "    node_data = pd.read_csv(\n",
    "        os.path.join(data_dir, \"cora.content\"), sep=\"\\t\", header=None, names=column_names\n",
    "    )\n",
    "\n",
    "    node_data.index = node_data.index.map(str)\n",
    "    node_data = node_data[node_data.index.isin(list(g_nx.nodes()))]\n",
    "\n",
    "    return g_nx, node_data, feature_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading the CORA network data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "The Cora dataset consists of 2708 scientific publications classified into one of seven classes. The citation network consists of 5429 links. Each publication in the dataset is described by a 0/1-valued word vector indicating the absence/presence of the corresponding word from the dictionary. The dictionary consists of 1433 unique words."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataset = datasets.Cora()\n",
    "display(HTML(dataset.description))\n",
    "dataset.download()\n",
    "G, node_data, feature_names = load_cora(dataset.data_directory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to convert node features that will be used by the model to numeric values that are required for GraphSAGE input. Note that all node features in the Cora dataset, except the categorical \"subject\" feature, are already numeric, and don't require the conversion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "if \"subject\" in feature_names:\n",
    "    # Convert node features to numeric vectors\n",
    "    feature_encoding = feature_extraction.DictVectorizer(sparse=False)\n",
    "    node_features = feature_encoding.fit_transform(\n",
    "        node_data[feature_names].to_dict(\"records\")\n",
    "    )\n",
    "else:  # node features are already numeric, no further conversion is needed\n",
    "    node_features = node_data[feature_names].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add node data to G:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "for nid, f in zip(node_data.index, node_features):\n",
    "    G.nodes[nid][globalvar.TYPE_ATTR_NAME] = \"paper\"  # specify node type\n",
    "    G.nodes[nid][\"feature\"] = f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We aim to train a link prediction model, hence we need to prepare the train and test sets of links and the corresponding graphs with those links removed.\n",
    "\n",
    "We are going to split our input graph into train and test graphs using the `EdgeSplitter` class in `stellargraph.data`. We will use the train graph for training the model (a binary classifier that, given two nodes, predicts whether a link between these two nodes should exist or not) and the test graph for evaluating the model's performance on hold out data.\n",
    "\n",
    "Each of these graphs will have the same number of nodes as the input graph, but the number of links will differ (be reduced) as some of the links will be removed during each split and used as the positive samples for training/testing the link prediction classifier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the original graph G, extract a randomly sampled subset of test edges (true and false citation links) and the reduced graph G_test with the positive test edges removed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "** Sampled 527 positive and 527 negative edges. **\n"
     ]
    }
   ],
   "source": [
    "# Define an edge splitter on the original graph G:\n",
    "edge_splitter_test = EdgeSplitter(G)\n",
    "\n",
    "# Randomly sample a fraction p=0.1 of all positive links, and same number of negative links, from G, and obtain the\n",
    "# reduced graph G_test with the sampled links removed:\n",
    "G_test, edge_ids_test, edge_labels_test = edge_splitter_test.train_test_split(\n",
    "    p=0.1, method=\"global\", keep_connected=True, seed=42\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reduced graph G_test, together with the test ground truth set of links (edge_ids_test, edge_labels_test), will be used for testing the model.\n",
    "\n",
    "Now, repeat this procedure to obtain validation data that we are going to use for early stopping in order to prevent overfitting. From the reduced graph G_test, extract a randomly sampled subset of validation edges (true and false citation links) and the reduced graph G_val with the positive validation edges removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "** Sampled 475 positive and 475 negative edges. **\n"
     ]
    }
   ],
   "source": [
    "# Define an edge splitter on the reduced graph G_test:\n",
    "edge_splitter_val = EdgeSplitter(G_test)\n",
    "\n",
    "# Randomly sample a fraction p=0.1 of all positive links, and same number of negative links, from G_test, and obtain the\n",
    "# reduced graph G_train with the sampled links removed:\n",
    "G_val, edge_ids_val, edge_labels_val = edge_splitter_val.train_test_split(\n",
    "    p=0.1, method=\"global\", keep_connected=True, seed=100\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We repeat this procedure one last time in order to obtain the training data for the model.\n",
    "From the reduced graph G_val, extract a randomly sampled subset of train edges (true and false citation links) and the reduced graph G_train with the positive train edges removed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "** Sampled 475 positive and 475 negative edges. **\n"
     ]
    }
   ],
   "source": [
    "# Define an edge splitter on the reduced graph G_test:\n",
    "edge_splitter_train = EdgeSplitter(G_test)\n",
    "\n",
    "# Randomly sample a fraction p=0.1 of all positive links, and same number of negative links, from G_test, and obtain the\n",
    "# reduced graph G_train with the sampled links removed:\n",
    "G_train, edge_ids_train, edge_labels_train = edge_splitter_train.train_test_split(\n",
    "    p=0.1, method=\"global\", keep_connected=True, seed=42\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "G_train, together with the train ground truth set of links (edge_ids_train, edge_labels_train), will be used for training the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert G_train, G_val, and G_test to StellarGraph objects (undirected, as required by GraphSAGE) for ML:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "G_train = sg.StellarGraph(G_train, node_features=\"feature\")\n",
    "G_test = sg.StellarGraph(G_test, node_features=\"feature\")\n",
    "G_val = sg.StellarGraph(G_val, node_features=\"feature\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Summary of G_train and G_test - note that they have the same set of nodes, only differing in their edge sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NetworkXStellarGraph: Undirected multigraph\n",
      " Nodes: 2708, Edges: 4276\n",
      "\n",
      " Node types:\n",
      "  paper: [2708]\n",
      "        Attributes: {'feature', 'subject'}\n",
      "    Edge types: paper-cites->paper\n",
      "\n",
      " Edge types:\n",
      "    paper-cites->paper: [4276]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(G_train.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NetworkXStellarGraph: Undirected multigraph\n",
      " Nodes: 2708, Edges: 4751\n",
      "\n",
      " Node types:\n",
      "  paper: [2708]\n",
      "        Attributes: {'feature', 'subject'}\n",
      "    Edge types: paper-cites->paper\n",
      "\n",
      " Edge types:\n",
      "    paper-cites->paper: [4751]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(G_test.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NetworkXStellarGraph: Undirected multigraph\n",
      " Nodes: 2708, Edges: 4276\n",
      "\n",
      " Node types:\n",
      "  paper: [2708]\n",
      "        Attributes: {'feature', 'subject'}\n",
      "    Edge types: paper-cites->paper\n",
      "\n",
      " Edge types:\n",
      "    paper-cites->paper: [4276]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(G_val.info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specify global parameters\n",
    "\n",
    "Here we specify some important parameters that control the type of ensemble model we are going to use. For example, we specify the number of models in the ensemble and the number of predictions per query point per model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_estimators = 5  # Number of models in the ensemble\n",
    "n_predictions = 10  # Number of predictions per query point per model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we create link generators for sampling and streaming train and test link examples to the model. The link generators essentially \"map\" pairs of nodes `(paper1, paper2)` to the input of GraphSAGE: they take minibatches of node pairs, sample 2-hop subgraphs with `(paper1, paper2)` head nodes extracted from those pairs, and feed them, together with the corresponding binary labels indicating whether those pairs represent true or false citation links, to the input layer of the GraphSAGE model, for SGD updates of the model parameters.\n",
    "\n",
    "Specify the minibatch size (number of node pairs per minibatch) and the number of epochs for training the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 20\n",
    "epochs = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specify the sizes of 1- and 2-hop neighbour samples for GraphSAGE. Note that the length of `num_samples` list defines the number of layers/iterations in the GraphSAGE model. In this example, we are defining a 2-layer GraphSAGE model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_samples = [20, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the generators for training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For training we create a generator on the `G_train` graph. The `shuffle=True` argument is given to the `flow` method to improve training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "generator = GraphSAGELinkGenerator(G_train, batch_size, num_samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_gen = generator.flow(edge_ids_train, edge_labels_train, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At test time we use the `G_test` graph and don't specify the `shuffle` argument (it defaults to `False`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_gen = GraphSAGELinkGenerator(G_test, batch_size, num_samples).flow(\n",
    "    edge_ids_test, edge_labels_test\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_gen = GraphSAGELinkGenerator(G_val, batch_size, num_samples).flow(\n",
    "    edge_ids_val, edge_labels_val\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the base GraphSAGE model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build the model: a 2-layer GraphSAGE model acting as node representation learner, with a link classification layer on concatenated `(paper1, paper2)` node embeddings.\n",
    "\n",
    "GraphSAGE part of the model, with hidden layer sizes of 20 for both GraphSAGE layers, a bias term, and no dropout. (Dropout can be switched on by specifying a positive dropout rate, 0 < dropout < 1)\n",
    "\n",
    "Note that the length of layer_sizes list must be equal to the length of num_samples, as len(num_samples) defines the number of hops (layers) in the GraphSAGE model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_sizes = [20, 20]\n",
    "assert len(layer_sizes) == len(num_samples)\n",
    "\n",
    "graphsage = GraphSAGE(\n",
    "    layer_sizes=layer_sizes, generator=generator, bias=True, dropout=0.5\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Build the model and expose the input and output tensors.\n",
    "x_inp, x_out = graphsage.build()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final link classification layer that takes a pair of node embeddings produced by graphsage, applies a binary operator to them to produce the corresponding link embedding ('ip' for inner product; other options for the binary operator can be seen by running a cell with `?link_classification` in it), and passes it through a dense layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "link_classification: using 'ip' method to combine node embeddings into edge embeddings\n"
     ]
    }
   ],
   "source": [
    "prediction = link_classification(\n",
    "    output_dim=1, output_act=\"relu\", edge_embedding_method=\"ip\"\n",
    ")(x_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stack the GraphSAGE and prediction layers into a Keras model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_model = keras.Model(inputs=x_inp, outputs=prediction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we create the ensemble based on `base_model` we just created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = BaggingEnsemble(\n",
    "    model=base_model, n_estimators=n_estimators, n_predictions=n_predictions\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to `compile` the model specifying the optimiser, loss function, and metrics to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(\n",
    "    optimizer=keras.optimizers.Adam(lr=1e-3),\n",
    "    loss=keras.losses.binary_crossentropy,\n",
    "    weighted_metrics=[\"acc\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the initial (untrained) ensemble of models on the train and test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Train Set Metrics of the initial (untrained) model:\n",
      "\tloss: 0.8341±0.1694\n",
      "\tacc: 0.6368±0.0097\n",
      "\n",
      "Test Set Metrics of the initial (untrained) model:\n",
      "\tloss: 0.8465±0.1267\n",
      "\tacc: 0.6314±0.0095\n"
     ]
    }
   ],
   "source": [
    "init_train_metrics_mean, init_train_metrics_std = model.evaluate_generator(train_gen)\n",
    "init_test_metrics_mean, init_test_metrics_std = model.evaluate_generator(test_gen)\n",
    "\n",
    "print(\"\\nTrain Set Metrics of the initial (untrained) model:\")\n",
    "for name, m, s in zip(\n",
    "    model.metrics_names, init_train_metrics_mean, init_train_metrics_std\n",
    "):\n",
    "    print(\"\\t{}: {:0.4f}±{:0.4f}\".format(name, m, s))\n",
    "\n",
    "print(\"\\nTest Set Metrics of the initial (untrained) model:\")\n",
    "for name, m, s in zip(model.metrics_names, init_test_metrics_mean, init_test_metrics_std):\n",
    "    print(\"\\t{}: {:0.4f}±{:0.4f}\".format(name, m, s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the ensemble model\n",
    "\n",
    "We are going to use **bootstrap samples** of the training dataset to train each model in the ensemble. For this purpose, we need to pass `generator`, `edge_ids_train`, and `edge_labels_train` to the `fit_generator` method.\n",
    "\n",
    "Note that training time will vary based on computer speed. Set `verbose=1` for reporting of training progress."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Early stopping conditioned on metric `val_weighted_acc` which is not available. Available metrics are: loss,acc,val_loss,val_acc\n"
     ]
    }
   ],
   "source": [
    "history = model.fit_generator(\n",
    "    generator=generator,\n",
    "    train_data=edge_ids_train,\n",
    "    train_targets=edge_labels_train,\n",
    "    epochs=epochs,\n",
    "    validation_data=val_gen,\n",
    "    verbose=0,\n",
    "    use_early_stopping=True,  # Enable early stopping\n",
    "    early_stopping_monitor=\"val_weighted_acc\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the training history:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the trained model on test citation links. After training the model, performance should be better than before training (shown above):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Train Set Metrics of the trained model:\n",
      "\tloss: 0.3454±0.0552\n",
      "\tacc: 0.9005±0.0061\n",
      "\n",
      "Test Set Metrics of the trained model:\n",
      "\tloss: 0.7539±0.1562\n",
      "\tacc: 0.7582±0.0183\n"
     ]
    }
   ],
   "source": [
    "train_metrics_mean, train_metrics_std = model.evaluate_generator(train_gen)\n",
    "test_metrics_mean, test_metrics_std = model.evaluate_generator(test_gen)\n",
    "\n",
    "print(\"\\nTrain Set Metrics of the trained model:\")\n",
    "for name, m, s in zip(model.metrics_names, train_metrics_mean, train_metrics_std):\n",
    "    print(\"\\t{}: {:0.4f}±{:0.4f}\".format(name, m, s))\n",
    "\n",
    "print(\"\\nTest Set Metrics of the trained model:\")\n",
    "for name, m, s in zip(model.metrics_names, test_metrics_mean, test_metrics_std):\n",
    "    print(\"\\t{}: {:0.4f}±{:0.4f}\".format(name, m, s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make predictions with the model\n",
    "\n",
    "Now let's get the predictions for all the edges in the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_predictions = model.predict_generator(generator=test_gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These predictions will be the output of the last layer in the model with `sigmoid` activation.\n",
    "\n",
    "The array `test_predictions` has dimensionality $MxKxNxF$ where $M$ is the number of estimators in the ensemble (`n_estimators`); $K$ is the number of predictions per query point per estimator (`n_predictions`); $N$ is the number of query points (`len(test_predictions)`); and $F$ is the output dimensionality of the specified layer determined by the shape of the output layer (in this case it is equal to 1 since we are performing binary classification)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, (5, 10, 1054, 1))"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(test_predictions), test_predictions.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For demonstration, we are going to select one of the edges in the test set, and plot the ensemble's predictions for that edge.\n",
    "\n",
    "Change the value of `selected_query_point` (valid values are in the range of `0` to `len(test_predictions)`) to visualise the results for another test point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_query_point = -10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 10, 1)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Select the predictios for the point specified by selected_query_point\n",
    "qp_predictions = test_predictions[:, :, selected_query_point, :]\n",
    "# The shape should be n_estimators x n_predictions x size_output_layer\n",
    "qp_predictions.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, to facilitate plotting the predictions using either a density plot or a box plot, we are going to reshape `qp_predictions` to $R\\times F$ where $R$ is equal to $M\\times K$ as above and $F$ is the output dimensionality of the output layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50, 1)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qp_predictions = qp_predictions.reshape(\n",
    "    np.product(qp_predictions.shape[0:-1]), qp_predictions.shape[-1]\n",
    ")\n",
    "qp_predictions.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model returns the probability of edge, the class to predict. The probability of no edge is just the complement of the latter. Let's calculate it so that we can plot the distribution of predictions for both outcomes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "qp_predictions = np.hstack((qp_predictions, 1.0 - qp_predictions,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'd like to assess the ensemble's confidence in its predictions in order to decide if we can trust them or not. Utilising a box plot, we can visually inspect the ensemble's distribution of prediction probabilities for a point in the test set.\n",
    "\n",
    "If the spread of values for the predicted point class is well separated from those of the other class with little overlap then we can be confident that the prediction is correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Class')"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "correct_label = \"Edge\"\n",
    "if edge_labels_test[selected_query_point] == 0:\n",
    "    correct_label = \"No Edge\"\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12, 6))\n",
    "ax.boxplot(x=qp_predictions)\n",
    "ax.set_xticklabels([\"Edge\", \"No Edge\"])\n",
    "ax.tick_params(axis=\"x\", rotation=45)\n",
    "plt.title(\"Correct label is \" + correct_label)\n",
    "plt.ylabel(\"Predicted Probability\")\n",
    "plt.xlabel(\"Class\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the selected pair of nodes (query point), the ensemble is not certain as to whether an edge between these two nodes should exist. This can be inferred by the large spread of values as indicated in the above figure.\n",
    "\n",
    "(Note that due to the stochastic nature of training neural network algorithms, the above conclusion may not be valid if you re-run the notebook; however, the general conclusion that the use of ensemble learning can be used to quantify the model's uncertainty about its prediction still holds.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The below image shows an example of the classifier making a correct prediction with higher confidence than the above example. The results is for the setting `selected_query_point=0`."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  }
 ],
 "metadata": {
  "file_extension": ".py",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
